package com.yifi.common;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URLEncoder;
import java.nio.channels.FileChannel;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.ProgressListener;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import com.jfinal.core.JFinal;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Record;

public class IOHelper {

	public static String GetRootPath() {

		// return
		// Controller.getSession().getServletContext().getRealPath("/WEB-INF/upload");
		// return Controller.getSession().getServletContext().getRealPath("");
		// return JFinal.me().getServletContext().getRealPath("");
		return com.jfinal.kit.PathKit.getWebRootPath();
	}

	public static String GetUploadPath() {
		String uploadPath = GetRootPath() + "/upload/";// yf_stmp/upload/
		return com.jfinal.kit.PropKit.get("path_upload", uploadPath);
	}

	public static String GetDatePath() {
		String datepath = new SimpleDateFormat("yyyy-MM").format(DBHelper
				.GetDateNow());// 当前月份目录
		return "attach/" + datepath + "/";
	}
	public static String GetDateTimePath() {
		String datepath = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss").format(DBHelper.GetDateNow());// 当前月份目录
		return "" + datepath + "/";
	}
	// 删除目录(包括下面所有目录及文件)
	public static boolean deleteDir(File dir) {
		if (dir.isDirectory()) {
			String[] children = dir.list();// 递归删除目录中的子目录下
			for (int i = 0; i < children.length; i++) {
				boolean success = deleteDir(new File(dir, children[i]));
				if (!success) {
					return false;
				}
			}
		}
		return dir.delete();// 目录此时为空，可以删除
	}

	// dirPath:如attach，即WEB-INF/upload/attach
	public static Record UploadFile(String dirPath, HttpServletRequest request) {

		Record recordFile = new Record();// 上传文件明细
		String savePath = GetUploadPath() + dirPath;
		File saveFile = new File(savePath);
		if (!saveFile.exists()) {// 创建上传目录
			saveFile.mkdirs();
		}
		String tempPath = GetUploadPath() + "temp";
		File tmpFile = new File(tempPath);
		if (!tmpFile.exists()) {// 创建临时目录
			tmpFile.mkdirs();
		}
		try {
			// 使用Apache文件上传组件处理文件上传步骤：
			// 1、创建一个DiskFileItemFactory工厂
			DiskFileItemFactory factory = new DiskFileItemFactory();
			// 设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
			factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
			// 设置上传时生成的临时文件的保存目录
			factory.setRepository(tmpFile);
			// 2、创建一个文件上传解析器
			ServletFileUpload upload = new ServletFileUpload(factory);
			// 监听文件上传进度
			upload.setProgressListener(new ProgressListener() {
				public void update(long pBytesRead, long pContentLength,
						int arg2) {
					System.out.println("文件大小为：" + pContentLength + ",当前已处理："
							+ pBytesRead);
					/** 文件大小为：14608,当前已处理：4096 **/
				}
			});
			// 解决上传文件名的中文乱码
			upload.setHeaderEncoding("UTF-8");
			// 3、判断提交上来的数据是否是上传表单的数据
			if (!ServletFileUpload.isMultipartContent(request)) {
				// 按照传统方式获取数据
				return null;
			}

			// 设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB
			// upload.setFileSizeMax(1024 * 1024);
			// 设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB
			// upload.setSizeMax(1024 * 1024 * 10);
			// 4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项

			List<Record> listF = new ArrayList<Record>();
			
			List<FileItem> list = upload.parseRequest(request);
			for (FileItem item : list) {
				//如果获取的 表单信息是普通的 文本 信息  
                if(item.isFormField())  
                {
                    //获取用户具体输入的字符串 ，名字起得挺好，因为表单提交过来的是 字符串类型的  
                    String ctext=item.getFieldName();
                    String value = new String(item.getString("UTF-8"));
                    recordFile.set(ctext, value);
                }
				if (!item.isFormField()) {// 如果fileitem中封装的是上传文件
					// 得到上传的文件名称，
					String filename = item.getName();
					System.out.println(filename);
					if (filename == null || filename.trim().equals("")) {
						continue;
					}
					// 注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如：
					// c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
					// 处理获取到的上传文件的文件名的路径部分，只保留文件名部分
					filename = filename
							.substring(filename.lastIndexOf("\\") + 1);
					// 得到上传文件的扩展名
					String fileExtName = filename.substring(filename
							.lastIndexOf(".") + 1);
					// 如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
					System.out.println("上传的文件的扩展名是：" + fileExtName);
					// 获取item中的上传文件的输入流
					InputStream in = item.getInputStream();
					int fsize = in.available();
					// 得到文件保存的名称,uuid+"_"+文件的原始名称
					String fid = UUID.randomUUID().toString();
					String saveFilename = "[" + fid + "]" + filename;
					String furl = dirPath + "/" + saveFilename;
					// 得到文件的保存目录
					// String realSavePath = makePath(saveFilename, savePath);
					// 创建一个文件输出流
					// FileOutputStream out = new FileOutputStream(realSavePath+
					// "\\" + saveFilename);
					FileOutputStream out = new FileOutputStream(savePath + "\\"
							+ saveFilename);
					// 创建一个缓冲区
					byte buffer[] = new byte[1024];
					// 判断输入流中的数据是否已经读完的标识
					int len = 0;
					// 循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
					while ((len = in.read(buffer)) > 0) {
						// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
						// + filename)当中
						out.write(buffer, 0, len);
					}
					// 关闭输入流
					in.close();
					// 关闭输出流
					out.close();
					// 删除处理文件上传时生成的临时文件
					item.delete();

					Record reF = new Record();
					reF.set("fid", fid);
					reF.set("fname", filename);
					reF.set("fext", fileExtName);
					reF.set("furl", furl);
					String fileSize = convertFileSize(fsize);// 文件大小
					reF.set("fsize", String.valueOf(fileSize));
					listF.add(reF);
					
					
					// 上传完成
				/*	recordFile.set("fid", fid);
					recordFile.set("fname", filename);
					recordFile.set("fext", fileExtName);
					recordFile.set("furl", furl);*/

				}
			}
			recordFile.set("listF", listF);
			
		} catch (FileUploadBase.FileSizeLimitExceededException e) {
			e.printStackTrace();// "单个文件超出最大值！"
			return null;
		} catch (FileUploadBase.SizeLimitExceededException e) {
			e.printStackTrace();// "上传文件的总的大小超出限制的最大值！"
			return null;
		} catch (Exception e) {
			e.printStackTrace();// "文件上传失败！"
			return null;
		}

		return recordFile;
	}

	// 生成guid文件名
	// dirPath:如attach，即WEB-INF/upload/attach
	public static Record UploadFile1(String dirPath, HttpServletRequest request) {

		Record recordFile = null;// 上传文件明细
		String savePath = GetUploadPath() + dirPath;
		File saveFile = new File(savePath);
		if (!saveFile.exists()) {// 创建上传目录
			saveFile.mkdirs();
		}
		String tempPath = GetUploadPath() + "temp";
		File tmpFile = new File(tempPath);
		if (!tmpFile.exists()) {// 创建临时目录
			tmpFile.mkdirs();
		}
		try {
			// 使用Apache文件上传组件处理文件上传步骤：
			// 1、创建一个DiskFileItemFactory工厂
			DiskFileItemFactory factory = new DiskFileItemFactory();
			// 设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
			factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
			// 设置上传时生成的临时文件的保存目录
			factory.setRepository(tmpFile);
			// 2、创建一个文件上传解析器
			ServletFileUpload upload = new ServletFileUpload(factory);
			// 监听文件上传进度
			upload.setProgressListener(new ProgressListener() {
				public void update(long pBytesRead, long pContentLength,
						int arg2) {
					System.out.println("文件大小为：" + pContentLength + ",当前已处理："
							+ pBytesRead);
					/** 文件大小为：14608,当前已处理：4096 **/
				}
			});
			// 解决上传文件名的中文乱码
			upload.setHeaderEncoding("UTF-8");
			// 3、判断提交上来的数据是否是上传表单的数据
			if (!ServletFileUpload.isMultipartContent(request)) {
				// 按照传统方式获取数据
				return null;
			}

			// 设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB
			// upload.setFileSizeMax(1024 * 1024);
			// 设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB
			// upload.setSizeMax(1024 * 1024 * 10);
			// 4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项
			List<FileItem> list = upload.parseRequest(request);
			for (FileItem item : list) {
				if (!item.isFormField()) {// 如果fileitem中封装的是上传文件
					// 得到上传的文件名称，
					String filename = item.getName();
					System.out.println(filename);
					if (filename == null || filename.trim().equals("")) {
						continue;
					}
					// 注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如：
					// c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
					// 处理获取到的上传文件的文件名的路径部分，只保留文件名部分
					filename = filename
							.substring(filename.lastIndexOf("\\") + 1);
					// 得到上传文件的扩展名
					String fileExtName = filename.substring(filename
							.lastIndexOf(".") + 1);
					// 如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
					System.out.println("上传的文件的扩展名是：" + fileExtName);
					// 获取item中的上传文件的输入流
					InputStream in = item.getInputStream();
					int fsize = in.available();
					// 得到文件保存的名称,uuid+"_"+文件的原始名称
					String fid = UUID.randomUUID().toString();
					String saveFilename = fid + "." + fileExtName;
					String furl = dirPath + "/" + saveFilename;
					// 得到文件的保存目录
					// String realSavePath = makePath(saveFilename, savePath);
					// 创建一个文件输出流
					// FileOutputStream out = new FileOutputStream(realSavePath+
					// "\\" + saveFilename);
					FileOutputStream out = new FileOutputStream(savePath + "\\"
							+ saveFilename);
					// 创建一个缓冲区
					byte buffer[] = new byte[1024];
					// 判断输入流中的数据是否已经读完的标识
					int len = 0;
					// 循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
					while ((len = in.read(buffer)) > 0) {
						// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
						// + filename)当中
						out.write(buffer, 0, len);
					}
					// 关闭输入流
					in.close();
					// 关闭输出流
					out.close();
					// 删除处理文件上传时生成的临时文件
					item.delete();

					// 上传完成
					recordFile = new Record();
					recordFile.set("fid", fid);
					recordFile.set("fname", filename);
					recordFile.set("fext", fileExtName);
					recordFile.set("furl", furl);

					String fileSize = convertFileSize(fsize);// 文件大小
					recordFile.set("fsize", String.valueOf(fileSize));
				}
			}
		} catch (FileUploadBase.FileSizeLimitExceededException e) {
			e.printStackTrace();// "单个文件超出最大值！"
			return null;
		} catch (FileUploadBase.SizeLimitExceededException e) {
			e.printStackTrace();// "上传文件的总的大小超出限制的最大值！"
			return null;
		} catch (Exception e) {
			e.printStackTrace();// "文件上传失败！"
			return null;
		}

		return recordFile;
	}

	public static boolean UploadFileSave(String filePath,
			HttpServletRequest request) {
		boolean result = false;

		String tempPath = GetUploadPath() + "temp";
		File tmpFile = new File(tempPath);
		if (!tmpFile.exists()) {// 创建临时目录
			tmpFile.mkdirs();
		}

		DiskFileItemFactory factory = new DiskFileItemFactory();
		factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
		factory.setRepository(tmpFile);
		ServletFileUpload upload = new ServletFileUpload(factory);
		upload.setHeaderEncoding("UTF-8");
		if (!ServletFileUpload.isMultipartContent(request)) {
			// 按照传统方式获取数据
			return false;
		}
		try {
			FileItem officeFileItem = null;
			List<FileItem> list = upload.parseRequest(request);
			for (FileItem item : list) {
				if (!item.isFormField()) {// 如果fileitem中封装的是上传文件
					officeFileItem = item;
				}
			}
			if (!filePath.equals("") && officeFileItem != null) {
				File officeFileUpload = new File(filePath);
				officeFileItem.write(officeFileUpload);
				result = true;
			}
		} catch (FileUploadException e) {
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			result = false;
		}
		return result;
	}

	public static String convertFileSize(long size) {
		long kb = 1024;
		long mb = kb * 1024;
		long gb = mb * 1024;

		if (size >= gb) {
			return String.format("%.1f GB", (float) size / gb);
		} else if (size >= mb) {
			float f = (float) size / mb;
			return String.format(f > 100 ? "%.0f MB" : "%.1f MB", f);
		} else if (size >= kb) {
			float f = (float) size / kb;
			return String.format(f > 100 ? "%.0f KB" : "%.1f KB", f);
		} else
			return String.format("%d B", size);
	}

	// 文件下载
	// furl：数据库中存放的路径，如attach/123.txt
	public static void DownloadFile(String fname, String furl,
			HttpServletResponse response) {

		// 上传的文件都是保存在/WEB-INF/upload目录下的子目录当中
		String fileSaveRootPath = GetUploadPath();
		// 通过文件名找出文件的所在目录
		String filePath = fileSaveRootPath + furl;
		// 得到要下载的文件
		File file = new File(filePath);
		// 如果文件不存在
		if (!file.exists()) {
			// request.setAttribute("message", "您要下载的资源已被删除！！");
			return;
		}
		try {
			// 设置响应头，控制浏览器下载该文件
			response.setHeader("content-disposition", "attachment;filename="
					+ URLEncoder.encode(fname, "UTF-8"));
			// 读取要下载的文件，保存到文件输入流
			FileInputStream in = new FileInputStream(filePath);
			// 创建输出流
			OutputStream out = response.getOutputStream();
			// 创建缓冲区
			byte buffer[] = new byte[1024];
			int len = 0;
			// 循环将输入流中的内容读取到缓冲区当中
			while ((len = in.read(buffer)) > 0) {
				// 输出缓冲区的内容到浏览器，实现文件下载
				out.write(buffer, 0, len);
			}
			// 关闭文件输入流
			in.close();
			// 关闭输出流
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 压缩文件
	public static void createZip(String sourcePath, String zipPath) {
        FileOutputStream fos = null;
        ZipOutputStream zos = null;
        try {
            fos = new FileOutputStream(zipPath);
            zos = new ZipOutputStream(fos);
            writeZip(new File(sourcePath), "", zos);
        } catch (FileNotFoundException e) {
            e.printStackTrace();  
        } finally {
            try {
                if (zos != null) {
                    zos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();  
            }
 
        }
    }
    private static void writeZip(File file, String parentPath, ZipOutputStream zos) {
        if(file.exists()){
            if(file.isDirectory()){//处理文件夹
                parentPath+=file.getName()+File.separator;
                File [] files=file.listFiles();
                for(File f:files){
                    writeZip(f, parentPath, zos);
                }
            }else{
                FileInputStream fis=null;
                DataInputStream dis=null;
                try {
                    fis=new FileInputStream(file);
                    dis=new DataInputStream(new BufferedInputStream(fis));
                    ZipEntry ze = new ZipEntry(parentPath + file.getName());
                    zos.putNextEntry(ze);
                    byte [] content=new byte[1024];
                    int len;
                    while((len=fis.read(content))!=-1){
                        zos.write(content,0,len);
                        zos.flush();
                    }
                     
                 
                } catch (FileNotFoundException e) {
                    e.printStackTrace();  
                } catch (IOException e) {
                    e.printStackTrace();  
                }finally{
                    try {
                        if(dis!=null){
                            dis.close();
                        }
                    }catch(IOException e){
                        e.printStackTrace();  
                    }
                }
            }
        }
    }   


	// 文件复制
	public static void FileCopy(String fileFromName, String fileToName) {
		try {
			int bytesum = 0;
			int byteread = 0;
			File oldfile = new File(fileFromName);
			if (oldfile.exists()) { // 文件存在时
				InputStream inStream = new FileInputStream(fileFromName); // 读入原文件
				FileOutputStream fs = new FileOutputStream(fileToName);
				byte[] buffer = new byte[1444];
				int length;
				while ((byteread = inStream.read(buffer)) != -1) {
					bytesum += byteread; // 字节数 文件大小
					System.out.println(bytesum);
					fs.write(buffer, 0, byteread);
				}
				fs.close();
				inStream.close();
			}
		} catch (Exception e) {
			System.out.println("复制单个文件操作出错");
			e.printStackTrace();

		}

	}
	
	//手机端数据上传
	
		// dirPath:如attach，即WEB-INF/upload/attach
		public static Record UploadFile(String savePath, String dirPath, HttpServletRequest request) {

			Record recordFile = null;// 上传文件明细
			// String savePath = GetUploadPath()+dirPath;
			File saveFile = new File(savePath);
			if (!saveFile.exists()) {// 创建上传目录
				saveFile.mkdirs();
			}
			String tempPath = GetUploadPath() + "temp";
			File tmpFile = new File(tempPath);
			if (!tmpFile.exists()) {// 创建临时目录
				tmpFile.mkdirs();
			}
			try {
				// 使用Apache文件上传组件处理文件上传步骤：
				// 1、创建一个DiskFileItemFactory工厂
				DiskFileItemFactory factory = new DiskFileItemFactory();
				// 设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
				factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
				// 设置上传时生成的临时文件的保存目录
				factory.setRepository(tmpFile);
				// 2、创建一个文件上传解析器
				ServletFileUpload upload = new ServletFileUpload(factory);
				// 监听文件上传进度
				upload.setProgressListener(new ProgressListener() {
					public void update(long pBytesRead, long pContentLength, int arg2) {
						System.out.println("文件大小为：" + pContentLength + ",当前已处理：" + pBytesRead);
						/** 文件大小为：14608,当前已处理：4096 **/
					}
				});
				// 解决上传文件名的中文乱码
				upload.setHeaderEncoding("UTF-8");
				// 3、判断提交上来的数据是否是上传表单的数据
				if (!ServletFileUpload.isMultipartContent(request)) {
					// 按照传统方式获取数据
					return null;
				}
				// 上传完成
				recordFile = new Record();

				// 设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB
				// upload.setFileSizeMax(1024 * 1024);
				// 设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB
				// upload.setSizeMax(1024 * 1024 * 10);
				// 4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项
				List<FileItem> list = upload.parseRequest(request);
				for (FileItem item : list) {

					// 如果获取的 表单信息是普通的 文本 信息
					if (item.isFormField()) {
						// 获取用户具体输入的字符串 ，名字起得挺好，因为表单提交过来的是 字符串类型的
						String ctext = item.getFieldName();
						String value = new String(item.getString("UTF-8"));
						recordFile.set(ctext, value);
					}
					if (!item.isFormField()) {// 如果fileitem中封装的是上传文件
						// 得到上传的文件名称，
						String filename = item.getName();
						System.out.println(filename);
						if (filename == null || filename.trim().equals("")) {
							continue;
						}
						// 注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如：
						// c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
						// 处理获取到的上传文件的文件名的路径部分，只保留文件名部分
						filename = filename.substring(filename.lastIndexOf("\\") + 1);
						// 得到上传文件的扩展名
						String fileExtName = filename.substring(filename.lastIndexOf(".") + 1);
						// 如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
						System.out.println("上传的文件的扩展名是：" + fileExtName);
						// 获取item中的上传文件的输入流
						InputStream in = item.getInputStream();
						int fsize = in.available();
						// 得到文件保存的名称,uuid+"_"+文件的原始名称
						String fid = UUID.randomUUID().toString();
						String saveFilename = filename; // "["+fid+"]"+
						String furl = dirPath + saveFilename;
						// 得到文件的保存目录
						// String realSavePath = makePath(saveFilename, savePath);
						// 创建一个文件输出流
						// FileOutputStream out = new FileOutputStream(realSavePath+
						// "\\" + saveFilename);
						FileOutputStream out = new FileOutputStream(savePath + "\\" + saveFilename);
						// 创建一个缓冲区
						byte buffer[] = new byte[1024];
						// 判断输入流中的数据是否已经读完的标识
						int len = 0;
						// 循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
						while ((len = in.read(buffer)) > 0) {
							// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
							// + filename)当中
							out.write(buffer, 0, len);
						}
						// 关闭输入流
						in.close();
						// 关闭输出流
						out.close();
						// 删除处理文件上传时生成的临时文件
						item.delete();

						recordFile.set("fid", fid);
						recordFile.set("fname", filename);
						recordFile.set("fext", fileExtName);
						recordFile.set("furl", furl);

						String fileSize = convertFileSize(fsize);// 文件大小
						recordFile.set("fsize", String.valueOf(fileSize));
					}
				}

				recordFile.set("fileNum", list.size() + "");
			} catch (FileUploadBase.FileSizeLimitExceededException e) {
				e.printStackTrace();// "单个文件超出最大值！"
				return null;
			} catch (FileUploadBase.SizeLimitExceededException e) {
				e.printStackTrace();// "上传文件的总的大小超出限制的最大值！"
				return null;
			} catch (Exception e) {
				e.printStackTrace();// "文件上传失败！"
				return null;
			}

			return recordFile;
		}
		
		//dirPath:如attach，即WEB-INF/upload/attach
		public static Record UploadFile(String savePath,String dirPath,HttpServletRequest request,String mid,String ctype) {

			Record recordFile = null;//上传文件明细
			//String savePath = GetUploadPath()+dirPath;
			File saveFile = new File(savePath);
			if (!saveFile.exists()) {// 创建上传目录
				saveFile.mkdirs();
			}
			String tempPath = GetUploadPath() +"temp";
			File tmpFile = new File(tempPath);
			if (!tmpFile.exists()) {// 创建临时目录
				tmpFile.mkdirs();
			}
			try {
				// 使用Apache文件上传组件处理文件上传步骤：
				// 1、创建一个DiskFileItemFactory工厂
				DiskFileItemFactory factory = new DiskFileItemFactory();
				// 设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
				factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
				// 设置上传时生成的临时文件的保存目录
				factory.setRepository(tmpFile);
				// 2、创建一个文件上传解析器
				ServletFileUpload upload = new ServletFileUpload(factory);
				// 监听文件上传进度
				upload.setProgressListener(new ProgressListener() {
					public void update(long pBytesRead, long pContentLength,int arg2) {
						System.out.println("文件大小为：" + pContentLength + ",当前已处理："+ pBytesRead);
						/**文件大小为：14608,当前已处理：4096**/
					}
				});
				// 解决上传文件名的中文乱码
				upload.setHeaderEncoding("UTF-8");
				// 3、判断提交上来的数据是否是上传表单的数据
				if (!ServletFileUpload.isMultipartContent(request)) {
					// 按照传统方式获取数据
					return null;
				}

				// 设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB
				//upload.setFileSizeMax(1024 * 1024);
				// 设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB
				//upload.setSizeMax(1024 * 1024 * 10);
				// 4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项
				List<FileItem> list = upload.parseRequest(request);
				for (FileItem item : list) {
					if (!item.isFormField()) {// 如果fileitem中封装的是上传文件
						// 得到上传的文件名称，
						String filename = item.getName();
						System.out.println(filename);
						if (filename == null || filename.trim().equals("")) {
							continue;
						}
						// 注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如：
						// c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
						// 处理获取到的上传文件的文件名的路径部分，只保留文件名部分
						filename = filename.substring(filename.lastIndexOf("\\") + 1);
						// 得到上传文件的扩展名
						String fileExtName = filename.substring(filename.lastIndexOf(".") + 1);
						// 如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
						System.out.println("上传的文件的扩展名是：" + fileExtName);
						// 获取item中的上传文件的输入流
						InputStream in = item.getInputStream();
						int fsize=in.available();
						// 得到文件保存的名称,uuid+"_"+文件的原始名称
						String fid = UUID.randomUUID().toString();
						String saveFilename = filename;   //"["+fid+"]"+ 
						String furl = dirPath+saveFilename;
						// 得到文件的保存目录
						//String realSavePath = makePath(saveFilename, savePath);
						// 创建一个文件输出流
						//FileOutputStream out = new FileOutputStream(realSavePath+ "\\" + saveFilename);
						FileOutputStream out = new FileOutputStream(savePath+ "\\" + saveFilename);
						// 创建一个缓冲区
						byte buffer[] = new byte[1024];
						// 判断输入流中的数据是否已经读完的标识
						int len = 0;
						// 循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
						while ((len = in.read(buffer)) > 0) {
							// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
							// + filename)当中
							out.write(buffer, 0, len);
						}
						// 关闭输入流
						in.close();
						// 关闭输出流
						out.close(); 
						//删除处理文件上传时生成的临时文件 
						item.delete(); 
						
						furl=furl.substring(furl.indexOf("/")+1);
						furl="attach/"+furl;
						String nowDate = "sysdate";
						String sql = "insert into mis_attach(id,cdesc,cpath,cext,m_id,cupload_user, cupload_org, ckey_word,cclassification,  dupload_date,cdoc_status,cfile_size,cfiletitle,cfull_url,isort,cdoc_type,st_flag)"
					            + " values('" + fid + "','" + filename + "','" + dirPath + "','" + fileExtName + "','" + mid + "','', '', '" + fid + "','1', " + nowDate + ",'1','" + fsize + "','" + filename + "','" + furl + "',1,'" + ctype + "','2')";
						Db.update(sql);
						
						//上传完成
						recordFile = new Record();
						recordFile.set("fid", fid);
						recordFile.set("fname", filename);
						recordFile.set("fext", fileExtName);
						recordFile.set("furl", furl);

						String fileSize = convertFileSize(fsize);//文件大小
						recordFile.set("fsize", String.valueOf(fileSize));
					}
				}

				recordFile.set("fileNum", list.size()+"");
			} catch (FileUploadBase.FileSizeLimitExceededException e) {
				e.printStackTrace();//"单个文件超出最大值！"
				return null;
			} catch (FileUploadBase.SizeLimitExceededException e) {
				e.printStackTrace();//"上传文件的总的大小超出限制的最大值！"
				return null;
			} catch (Exception e) {
				e.printStackTrace();//"文件上传失败！"
				return null;
			}
			
			return recordFile;
		}
		// dirPath:如attach，即WEB-INF/upload/attach
		public static Record UploadFile(String savePath, String dirPath, HttpServletRequest request, String mid,
				String user,String cdept,String cprj,String ctype,String remark) {

			Record recordFile = null;// 上传文件明细
			// String savePath = GetUploadPath()+dirPath;
			File saveFile = new File(savePath);
			if (!saveFile.exists()) {// 创建上传目录
				saveFile.mkdirs();
			}
			String tempPath = GetUploadPath() + "temp";
			File tmpFile = new File(tempPath);
			if (!tmpFile.exists()) {// 创建临时目录
				tmpFile.mkdirs();
			}
			try {
				// 使用Apache文件上传组件处理文件上传步骤：
				// 1、创建一个DiskFileItemFactory工厂
				DiskFileItemFactory factory = new DiskFileItemFactory();
				// 设置工厂的缓冲区的大小，当上传的文件大小超过缓冲区的大小时，就会生成一个临时文件存放到指定的临时目录当中。
				factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB，如果不指定，那么缓冲区的大小默认是10KB
				// 设置上传时生成的临时文件的保存目录
				factory.setRepository(tmpFile);
				// 2、创建一个文件上传解析器
				ServletFileUpload upload = new ServletFileUpload(factory);
				// 监听文件上传进度
				upload.setProgressListener(new ProgressListener() {
					public void update(long pBytesRead, long pContentLength, int arg2) {
						System.out.println("文件大小为：" + pContentLength + ",当前已处理：" + pBytesRead);
						/** 文件大小为：14608,当前已处理：4096 **/
					}
				});
				// 解决上传文件名的中文乱码
				upload.setHeaderEncoding("UTF-8");
				// 3、判断提交上来的数据是否是上传表单的数据
				if (!ServletFileUpload.isMultipartContent(request)) {
					// 按照传统方式获取数据
					return null;
				}

				// 设置上传单个文件的大小的最大值，目前是设置为1024*1024字节，也就是1MB
				// upload.setFileSizeMax(1024 * 1024);
				// 设置上传文件总量的最大值，最大值=同时上传的多个文件的大小的最大值的和，目前设置为10MB
				// upload.setSizeMax(1024 * 1024 * 10);
				// 4、使用ServletFileUpload解析器解析上传数据，解析结果返回的是一个List<FileItem>集合，每一个FileItem对应一个Form表单的输入项
				List<FileItem> list = upload.parseRequest(request);
				for (FileItem item : list) {
					if (!item.isFormField()) {// 如果fileitem中封装的是上传文件
						// 得到上传的文件名称，
						String filename = item.getName();
						System.out.println(filename);
						if (filename == null || filename.trim().equals("")) {
							continue;
						}
						// 注意：不同的浏览器提交的文件名是不一样的，有些浏览器提交上来的文件名是带有路径的，如：
						// c:\a\b\1.txt，而有些只是单纯的文件名，如：1.txt
						// 处理获取到的上传文件的文件名的路径部分，只保留文件名部分
						filename = filename.substring(filename.lastIndexOf("\\") + 1);
						// 得到上传文件的扩展名
						String fileExtName = filename.substring(filename.lastIndexOf(".") + 1);
						// 如果需要限制上传的文件类型，那么可以通过文件的扩展名来判断上传的文件类型是否合法
						System.out.println("上传的文件的扩展名是：" + fileExtName);
						// 获取item中的上传文件的输入流
						InputStream in = item.getInputStream();
						int fsize = in.available();
						// 得到文件保存的名称,uuid+"_"+文件的原始名称
						String fid = UUID.randomUUID().toString();
						String saveFilename = filename; // "["+fid+"]"+
						String furl = dirPath + saveFilename;
						// 得到文件的保存目录
						// String realSavePath = makePath(saveFilename, savePath);
						// 创建一个文件输出流
						// FileOutputStream out = new FileOutputStream(realSavePath+
						// "\\" + saveFilename);
						FileOutputStream out = new FileOutputStream(savePath + "\\" + saveFilename);
						// 创建一个缓冲区
						byte buffer[] = new byte[1024];
						// 判断输入流中的数据是否已经读完的标识
						int len = 0;
						// 循环将输入流读入到缓冲区当中，(len=in.read(buffer))>0就表示in里面还有数据
						while ((len = in.read(buffer)) > 0) {
							// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
							// + filename)当中
							out.write(buffer, 0, len);
						}
						// 关闭输入流
						in.close();
						// 关闭输出流
						out.close();
						// 删除处理文件上传时生成的临时文件
						item.delete();
						

						furl = furl.substring(furl.indexOf("/") + 1);
						furl = "attach/" + furl;
						String nowDate = "sysdate";
						String sql = "insert into mis_attach(id,cdesc,cpath,cext,m_id,cupload_user, cupload_org, ckey_word,cclassification,  dupload_date,cdoc_status,cfile_size,cfiletitle,cfull_url,isort,cdoc_type,st_flag)"
								+ " values('" + fid + "','" + filename + "','" + dirPath + "','" + fileExtName + "','" + mid
								+ "','', '', '" + fid + "','1', " + nowDate + ",'1','" + fsize + "','" + filename + "','"
								+ furl + "',1,'" + ctype + "','2')";
						Db.update(sql);

						
						Record record=new Record();
						record.set("id", SysUtil.getGuid());
						record.set("cname", ctype);
						record.set("c01", remark);
						record.set("fj_id", fid);
						record.set("c02", user);
						record.set("d03",DBHelper.GetDateNow());
						record.set("c04", cdept);
						record.set("cproject", cprj);
						Db.save("pbim_pz", "id", record);
						
						// 上传完成
						recordFile = new Record();
						recordFile.set("fid", fid);
						recordFile.set("fname", filename);
						recordFile.set("fext", fileExtName);
						recordFile.set("furl", furl);

						String fileSize = convertFileSize(fsize);// 文件大小
						recordFile.set("fsize", String.valueOf(fileSize));
					}
				}

				recordFile.set("fileNum", list.size() + "");
			} catch (FileUploadBase.FileSizeLimitExceededException e) {
				e.printStackTrace();// "单个文件超出最大值！"
				return null;
			} catch (FileUploadBase.SizeLimitExceededException e) {
				e.printStackTrace();// "上传文件的总的大小超出限制的最大值！"
				return null;
			} catch (Exception e) {
				e.printStackTrace();// "文件上传失败！"
				return null;
			}

			return recordFile;
		}
		public static String getWebUploadPath() {
			String uploadPath = GetRootPath();
			return uploadPath;
		}
}
